ஜாவாஸ்கிரிப்ட் அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள்: ஸ்ட்ரீம் உருவாக்கம் மற்றும் நிர்வாகத்தில் தேர்ச்சி பெறுதல்

ஜாவாஸ்கிரிப்ட்டில் உள்ள அசிங்க்ரோனஸ் புரோகிராமிங் பல ஆண்டுகளாக குறிப்பிடத்தக்க அளவில் வளர்ந்துள்ளது. அசிங்க் ஜெனரேட்டர்கள் மற்றும் அசிங்க் இட்டரேட்டர்களின் அறிமுகத்துடன், டெவலப்பர்கள் அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களைக் கையாள சக்திவாய்ந்த கருவிகளைப் பெற்றனர். இப்போது, ஜாவாஸ்கிரிப்ட் அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் இந்த திறன்களை மேலும் மேம்படுத்துகின்றன, அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களை உருவாக்க, மாற்ற மற்றும் நிர்வகிக்க மிகவும் நெறிப்படுத்தப்பட்ட மற்றும் வெளிப்படையான வழியை வழங்குகின்றன. இந்த வழிகாட்டி அசிங்க் ஜெனரேட்டர் ஹெல்பர்களின் அடிப்படைகளை ஆராய்கிறது, அவற்றின் செயல்பாடுகளில் ஆழமாகச் செல்கிறது, மற்றும் தெளிவான எடுத்துக்காட்டுகளுடன் அவற்றின் நடைமுறை பயன்பாடுகளை நிரூபிக்கிறது.

அசிங்க் ஜெனரேட்டர்கள் மற்றும் இட்டரேட்டர்களைப் புரிந்துகொள்ளுதல்

அசிங்க் ஜெனரேட்டர் ஹெல்பர்களுக்குள் செல்வதற்கு முன், அசிங்க் ஜெனரேட்டர்கள் மற்றும் அசிங்க் இட்டரேட்டர்களின் அடிப்படைக் கருத்துக்களைப் புரிந்துகொள்வது முக்கியம்.

அசிங்க் ஜெனரேட்டர்கள்

ஒரு அசிங்க் ஜெனரேட்டர் என்பது ஒரு செயல்பாடு ஆகும், அதை இடைநிறுத்தி மீண்டும் இயக்க முடியும், மதிப்புகளை அசிங்க்ரோனஸ் முறையில் வழங்குகிறது. இது பிரதான த்ரெட்டைத் தடுக்காமல், காலப்போக்கில் மதிப்புகளின் வரிசையை உருவாக்க உங்களை அனுமதிக்கிறது. அசிங்க் ஜெனரேட்டர்கள் async function* தொடரியலைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன.

உதாரணம்:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // அசிங்க்ரோனஸ் செயல்பாட்டை உருவகப்படுத்துதல்
    yield i;
  }
}

// பயன்பாடு
const sequence = generateSequence(1, 5);

அசிங்க் இட்டரேட்டர்கள்

ஒரு அசிங்க் இட்டரேட்டர் என்பது ஒரு பொருள் ஆகும், அது next() முறையை வழங்குகிறது, இது ஒரு ப்ராமிஸைத் திருப்பித் தருகிறது, அது வரிசையில் அடுத்த மதிப்பைக் கொண்ட ஒரு பொருளுக்குத் தீர்க்கிறது மற்றும் வரிசை தீர்ந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு done பண்பு. அசிங்க் இட்டரேட்டர்கள் for await...of லூப்களைப் பயன்படுத்தி நுகரப்படுகின்றன.

உதாரணம்:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield i;
  }
}

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

அசிங்க் ஜெனரேட்டர் ஹெல்பர்களை அறிமுகப்படுத்துதல்

அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் என்பது அசிங்க் ஜெனரேட்டர் புரோட்டோடைப்களின் செயல்பாட்டை நீட்டிக்கும் முறைகளின் தொகுப்பாகும். அவை அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களைக் கையாள வசதியான வழிகளை வழங்குகின்றன, இது குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது. இந்த ஹெல்பர்கள் சோம்பேறித்தனமாக செயல்படுகின்றன, அதாவது தேவைப்படும்போது மட்டுமே தரவைச் செயலாக்குகின்றன, இது செயல்திறனை மேம்படுத்தும்.

பின்வரும் அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் பொதுவாகக் கிடைக்கின்றன (ஜாவாஸ்கிரிப்ட் சூழல் மற்றும் பாலிஃபில்களைப் பொறுத்து):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

அசிங்க் ஜெனரேட்டர் ஹெல்பர்களின் விரிவான ஆய்வு

1. `map()`

map() ஹெல்பர், வழங்கப்பட்ட செயல்பாட்டைப் பயன்படுத்துவதன் மூலம் அசிங்க்ரோனஸ் வரிசையில் உள்ள ஒவ்வொரு மதிப்பையும் மாற்றுகிறது. இது மாற்றப்பட்ட மதிப்புகளை வழங்கும் ஒரு புதிய அசிங்க் ஜெனரேட்டரைத் திருப்பித் தருகிறது.

தொடரியல்:

asyncGenerator.map(callback)

உதாரணம்: எண்களின் ஸ்ட்ரீமை அவற்றின் வர்க்கங்களாக மாற்றுதல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // அசிங்க் செயல்பாட்டை உருவகப்படுத்துதல்
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: பல APIகளிலிருந்து பயனர் தரவைப் பெறுவதையும், அந்தத் தரவை ஒரு சீரான வடிவத்திற்கு மாற்ற வேண்டிய தேவையையும் கற்பனை செய்து பாருங்கள். ஒவ்வொரு பயனர் பொருளுக்கும் அசிங்க்ரோனஸ் முறையில் ஒரு மாற்றச் செயல்பாட்டைப் பயன்படுத்த map() பயன்படுத்தப்படலாம்.

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // பயனர் தரவு வடிவத்தை இயல்பாக்குதல்
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

2. `filter()`

filter() ஹெல்பர் ஒரு புதிய அசிங்க் ஜெனரேட்டரை உருவாக்குகிறது, இது அசல் வரிசையிலிருந்து வழங்கப்பட்ட நிபந்தனையை பூர்த்தி செய்யும் மதிப்புகளை மட்டுமே வழங்குகிறது. இதன் மூலம் இதன் விளைவாக வரும் ஸ்ட்ரீமில் மதிப்புகளைத் தேர்ந்தெடுத்து சேர்க்க உங்களை அனுமதிக்கிறது.

தொடரியல்:

asyncGenerator.filter(callback)

உதாரணம்: இரட்டைப்படை எண்களை மட்டும் சேர்க்க எண்களின் ஸ்ட்ரீமை வடிகட்டுதல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: பதிவு உள்ளீடுகளின் ஸ்ட்ரீமை செயலாக்கி, அவற்றின் கடுமை நிலையின் அடிப்படையில் உள்ளீடுகளை வடிகட்டுதல். உதாரணமாக, பிழைகள் மற்றும் எச்சரிக்கைகளை மட்டும் செயலாக்குதல்.

async function* readLogFile(filePath) {
  // ஒரு பதிவு கோப்பை வரி வரியாக அசிங்க்ரோனஸ் முறையில் படிக்கும் உருவகப்படுத்துதல்
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

3. `take()`

take() ஹெல்பர் ஒரு புதிய அசிங்க் ஜெனரேட்டரை உருவாக்குகிறது, இது அசல் வரிசையிலிருந்து முதல் n மதிப்புகளை மட்டுமே வழங்குகிறது. இது ஒரு எல்லையற்ற அல்லது மிக பெரிய ஸ்ட்ரீமிலிருந்து செயலாக்கப்படும் உருப்படிகளின் எண்ணிக்கையைக் கட்டுப்படுத்த பயனுள்ளதாக இருக்கும்.

தொடரியல்:

asyncGenerator.take(n)

உதாரணம்: எண்களின் ஸ்ட்ரீமிலிருந்து முதல் 3 எண்களை எடுத்தல்.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: ஒரு அசிங்க்ரோனஸ் தேடல் APIயிலிருந்து முதல் 5 தேடல் முடிவுகளைக் காண்பித்தல்.

async function* search(query) {
  // ஒரு APIயிலிருந்து தேடல் முடிவுகளைப் பெறுவதை உருவகப்படுத்துதல்
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

4. `drop()`

drop() ஹெல்பர் ஒரு புதிய அசிங்க் ஜெனரேட்டரை உருவாக்குகிறது, இது அசல் வரிசையிலிருந்து முதல் n மதிப்புகளைத் தவிர்த்து மீதமுள்ள மதிப்புகளை வழங்குகிறது. இது take() என்பதற்கு எதிரானது மற்றும் ஒரு ஸ்ட்ரீமின் ஆரம்ப பகுதிகளைப் புறக்கணிக்க பயனுள்ளதாக இருக்கும்.

தொடரியல்:

asyncGenerator.drop(n)

உதாரணம்: எண்களின் ஸ்ட்ரீமிலிருந்து முதல் 2 எண்களை விடுதல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: ஒரு APIயிலிருந்து பெறப்பட்ட ஒரு பெரிய தரவுத்தொகுப்பில் பக்க வாரியாகச் செல்லுதல், ஏற்கனவே காட்டப்பட்ட முடிவுகளைத் தவிர்த்தல்.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // ஆஃப்செட் உடன் தரவைப் பெறுவதை உருவகப்படுத்துதல்
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // முந்தைய பக்கங்களில் உள்ள உருப்படிகளைத் தவிர்க்கவும்

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// எடுத்துக்காட்டு பயன்பாடு
displayPage(2);

5. `flatMap()`

flatMap() ஹெல்பர் அசிங்க்ரோனஸ் வரிசையில் உள்ள ஒவ்வொரு மதிப்பையும் ஒரு அசிங்க் இட்டரபிளைத் தரும் ஒரு செயல்பாட்டைப் பயன்படுத்தி மாற்றுகிறது. பின்னர் அது விளைந்த அசிங்க் இட்டரபிளை ஒரு ஒற்றை அசிங்க் ஜெனரேட்டராக தட்டையாக்குகிறது. இது ஒவ்வொரு மதிப்பையும் மதிப்புகளின் ஸ்ட்ரீமாக மாற்றி, பின்னர் அந்த ஸ்ட்ரீம்களை இணைப்பதற்கு பயனுள்ளதாக இருக்கும்.

தொடரியல்:

asyncGenerator.flatMap(callback)

உதாரணம்: வாக்கியங்களின் ஸ்ட்ரீமை வார்த்தைகளின் ஸ்ட்ரீமாக மாற்றுதல்.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

நிஜ உலக பயன்பாட்டு வழக்கு: பல வலைப்பதிவு இடுகைகளுக்கான கருத்துக்களைப் பெற்று, அவற்றைச் செயலாக்குவதற்காக ஒரு ஒற்றை ஸ்ட்ரீமில் இணைத்தல்.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // ஒரு APIயிலிருந்து வலைப்பதிவு இடுகை ஐடிகளைப் பெறுவதை உருவகப்படுத்துதல்
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // ஒரு APIயிலிருந்து வலைப்பதிவு இடுகைக்கான கருத்துக்களைப் பெறுவதை உருவகப்படுத்துதல்
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

6. `reduce()`

reduce() ஹெல்பர் ஒரு திரட்டி மற்றும் அசிங்க் ஜெனரேட்டரின் ஒவ்வொரு மதிப்புக்கு எதிராக (இடமிருந்து வலமாக) ஒரு செயல்பாட்டைப் பயன்படுத்துகிறது, அதை ஒரு ஒற்றை மதிப்பாகக் குறைக்கிறது. இது ஒரு அசிங்க்ரோனஸ் ஸ்ட்ரீமிலிருந்து தரவை ஒருங்கிணைப்பதற்கு பயனுள்ளதாக இருக்கும்.

தொடரியல்:

asyncGenerator.reduce(callback, initialValue)

உதாரணம்: ஒரு ஸ்ட்ரீமில் உள்ள எண்களின் கூட்டுத்தொகையைக் கணக்கிடுதல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: தொடர்ச்சியான API அழைப்புகளின் சராசரி மறுமொழி நேரத்தைக் கணக்கிடுதல்.

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // அல்லது பிழையை சரியான முறையில் கையாளவும்
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

7. `toArray()`

toArray() ஹெல்பர் அசிங்க் ஜெனரேட்டரை நுகர்ந்து, ஜெனரேட்டர் வழங்கிய அனைத்து மதிப்புகளையும் கொண்ட ஒரு வரிசையாக தீர்க்கப்படும் ஒரு ப்ராமிஸைத் திருப்பித் தருகிறது. நீங்கள் ஸ்ட்ரீமிலிருந்து அனைத்து மதிப்புகளையும் ஒரு ஒற்றை வரிசையில் சேகரிக்க வேண்டியிருக்கும் போது இது பயனுள்ளதாக இருக்கும்.

தொடரியல்:

asyncGenerator.toArray()

உதாரணம்: ஒரு ஸ்ட்ரீமிலிருந்து எண்களை ஒரு வரிசையில் சேகரித்தல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: கிளையன்ட் பக்கத்தில் வடிகட்டுதல் அல்லது வரிசைப்படுத்துதலுக்காக ஒரு பக்கப்படுத்தப்பட்ட APIயிலிருந்து அனைத்து உருப்படிகளையும் ஒரு ஒற்றை வரிசையில் சேகரித்தல்.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // APIயின் பக்க வரம்புகளைப் பொறுத்து சரிசெய்யவும்

    while (true) {
        const url = `${apiEndpoint}?page=${pageNumber}&pageSize=${pageSize}`;
        const response = await fetch(url);
        const data = await response.json();

        if (!data || data.length === 0) {
            break; // மேலும் தரவு இல்லை
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // `itemsArray` இல் மேலும் செயலாக்கம் செய்யலாம்
}

8. `forEach()`

forEach() ஹெல்பர் அசிங்க் ஜெனரேட்டரில் உள்ள ஒவ்வொரு மதிப்புக்கும் ஒரு முறை வழங்கப்பட்ட செயல்பாட்டை செயல்படுத்துகிறது. மற்ற ஹெல்பர்களைப் போலல்லாமல், forEach() ஒரு புதிய அசிங்க் ஜெனரேட்டரைத் திருப்பித் தராது; இது ஒவ்வொரு மதிப்பிலும் பக்க விளைவுகளைச் செய்யப் பயன்படுகிறது.

தொடரியல்:

asyncGenerator.forEach(callback)

உதாரணம்: ஒரு ஸ்ட்ரீமில் உள்ள ஒவ்வொரு எண்ணையும் கன்சோலில் பதிவு செய்தல்.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: ஒரு ஸ்ட்ரீமிலிருந்து தரவு செயலாக்கப்படும்போது ஒரு பயனர் இடைமுகத்திற்கு நிகழ்நேர புதுப்பிப்புகளை அனுப்புதல்.

async function* fetchRealTimeData(dataSource) {
    // நிகழ்நேர தரவைப் பெறுவதை உருவகப்படுத்துதல் (எ.கா. பங்கு விலைகள்).
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    // UI புதுப்பிப்பதை உருவகப்படுத்துதல்
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // UI ஐ உண்மையில் புதுப்பிப்பதற்கான குறியீடு இங்கு வரும்.
  });
}

சிக்கலான தரவு பைப்லைன்களுக்கு அசிங்க் ஜெனரேட்டர் ஹெல்பர்களை இணைத்தல்

அசிங்க் ஜெனரேட்டர் ஹெல்பர்களின் உண்மையான சக்தி, சிக்கலான தரவு பைப்லைன்களை உருவாக்க அவற்றை ஒன்றாக இணைக்கும் திறனிலிருந்து வருகிறது. இது ஒரு அசிங்க்ரோனஸ் ஸ்ட்ரீமில் பல மாற்றங்கள் மற்றும் செயல்பாடுகளை ஒரு சுருக்கமான மற்றும் படிக்கக்கூடிய வழியில் செய்ய உங்களை அனுமதிக்கிறது.

உதாரணம்: இரட்டைப்படை எண்களை மட்டும் சேர்க்க எண்களின் ஸ்ட்ரீமை வடிகட்டுதல், பின்னர் அவற்றை வர்க்கப்படுத்துதல், மற்றும் இறுதியாக முதல் 3 முடிவுகளை எடுத்தல்.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

நிஜ உலக பயன்பாட்டு வழக்கு: பயனர் தரவைப் பெறுதல், அவர்களின் இருப்பிடத்தின் அடிப்படையில் பயனர்களை வடிகட்டுதல், அவர்களின் தரவை தொடர்புடைய புலங்களை மட்டும் சேர்க்க மாற்றுதல், பின்னர் முதல் 10 பயனர்களை ஒரு வரைபடத்தில் காண்பித்தல்.

async function* fetchUsers() {
  // ஒரு தரவுத்தளம் அல்லது APIயிலிருந்து பயனர்களைப் பெறுவதை உருவகப்படுத்துதல்
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// பயன்பாட்டு எடுத்துக்காட்டுகள்:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

பாலிஃபில்கள் மற்றும் உலாவி ஆதரவு

அசிங்க் ஜெனரேட்டர் ஹெல்பர்களுக்கான ஆதரவு ஜாவாஸ்கிரிப்ட் சூழலைப் பொறுத்து மாறுபடலாம். நீங்கள் பழைய உலாவிகள் அல்லது சூழல்களை ஆதரிக்க வேண்டியிருந்தால், நீங்கள் பாலிஃபில்களைப் பயன்படுத்த வேண்டியிருக்கலாம். ஒரு பாலிஃபில், ஜாவாஸ்கிரிப்ட்டில் அதை செயல்படுத்துவதன் மூலம் விடுபட்ட செயல்பாட்டை வழங்குகிறது. அசிங்க் ஜெனரேட்டர் ஹெல்பர்களுக்கு பல பாலிஃபில் நூலகங்கள் கிடைக்கின்றன, যেমন core-js.

core-js ஐப் பயன்படுத்தி எடுத்துக்காட்டு:

// தேவையான பாலிஃபில்களை இறக்குமதி செய்யவும்
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... தேவையான மற்ற ஹெல்பர்களை இறக்குமதி செய்யவும்

பிழை கையாளுதல்

அசிங்க்ரோனஸ் செயல்பாடுகளுடன் பணிபுரியும் போது, பிழைகளைச் சரியாகக் கையாள்வது முக்கியம். அசிங்க் ஜெனரேட்டர் ஹெல்பர்களுடன், ஹெல்பர்களில் பயன்படுத்தப்படும் அசிங்க்ரோனஸ் செயல்பாடுகளுக்குள் try...catch பிளாக்குகளைப் பயன்படுத்தி பிழை கையாளுதல் செய்யப்படலாம்.

உதாரணம்: ஒரு map() செயல்பாட்டிற்குள் தரவைப் பெறும்போது பிழைகளைக் கையாளுதல்.

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // அல்லது பிழையை சரியான முறையில் கையாளவும், எ.கா., ஒரு பிழைப் பொருளை அளிப்பதன் மூலம்
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // பிழையை பரப்புங்கள்
    }
    // தரவைச் செயலாக்கவும்
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

சிறந்த நடைமுறைகள் மற்றும் பரிசீலனைகள்

• சோம்பேறி மதிப்பீடு: அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் சோம்பேறித்தனமாக மதிப்பிடப்படுகின்றன, அதாவது கோரப்படும்போது மட்டுமே அவை தரவைச் செயலாக்குகின்றன. இது செயல்திறனை மேம்படுத்தும், குறிப்பாக பெரிய தரவுத்தொகுப்புகளுடன் கையாளும்போது.
• பிழை கையாளுதல்: ஹெல்பர்களில் பயன்படுத்தப்படும் அசிங்க்ரோனஸ் செயல்பாடுகளுக்குள் எப்போதும் பிழைகளைச் சரியாகக் கையாளவும்.
• பாலிஃபில்கள்: பழைய உலாவிகள் அல்லது சூழல்களை ஆதரிக்கத் தேவைப்படும்போது பாலிஃபில்களைப் பயன்படுத்தவும்.
• படிக்கக்கூடிய தன்மை: உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் மாற்ற விளக்கமான மாறி பெயர்கள் மற்றும் கருத்துகளைப் பயன்படுத்தவும்.
• செயல்திறன்: பல ஹெல்பர்களை ஒன்றாக இணைப்பதன் செயல்திறன் தாக்கங்களைக் கவனத்தில் கொள்ளவும். சோம்பேறித்தனம் உதவினாலும், அதிகப்படியான இணைப்பு இன்னும் கூடுதல் சுமையை அறிமுகப்படுத்தலாம்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களை உருவாக்க, மாற்ற மற்றும் நிர்வகிக்க ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான வழியை வழங்குகின்றன. இந்த ஹெல்பர்களைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் சிக்கலான அசிங்க்ரோனஸ் செயல்பாடுகளைக் கையாள மிகவும் சுருக்கமான, படிக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய குறியீட்டை எழுதலாம். அசிங்க் ஜெனரேட்டர்கள் மற்றும் இட்டரேட்டர்களின் அடிப்படைகள், ஒவ்வொரு ஹெல்பரின் செயல்பாடுகளுடன், நிஜ உலக பயன்பாடுகளில் இந்த கருவிகளை திறம்படப் பயன்படுத்துவதற்கு அவசியமானவை. நீங்கள் தரவு பைப்லைன்களை உருவாக்குகிறீர்களா, நிகழ்நேர தரவைச் செயலாக்குகிறீர்களா, அல்லது அசிங்க்ரோனஸ் API பதில்களைக் கையாளுகிறீர்களா, அசிங்க் ஜெனரேட்டர் ஹெல்பர்கள் உங்கள் குறியீட்டை கணிசமாக எளிதாக்கலாம் மற்றும் அதன் ஒட்டுமொத்த செயல்திறனை மேம்படுத்தலாம்.